/*
Known bugs:
- * Compressed files don't work yet
- * bi-tonal files aren't tested
+ * 4bpp compressed files don't work
+ * bi-tonal files aren't tested with palettes
*/
#include <config.h>
#include <stdio.h>
#include <unistd.h>
-#include "gdk-pixbuf.h"
-#include "gdk-pixbuf-io.h"
-
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk-pixbuf/gdk-pixbuf-io.h>
\f
-struct headerpair {
- guint width;
- guint height;
- guint depth;
- guint Negative; /* Negative = 1 -> top down BMP,
- Negative = 0 -> bottom up BMP */
-};
+
/*
These structures are actually dummies. These are according to
-the "Windows API reference guide volume II" as written by Borland,
-but GCC fiddles with the alignment of the internal members.
+the "Windows API reference guide volume II" as written by
+Borland International, but GCC fiddles with the alignment of
+the internal members, so these aren't actually usable.
*/
guint biClrImportant;
};
+/*
+
+DumpBIH printf's the values in a BitmapInfoHeader to the screen, for
+debugging purposes.
+
+*/
+#if DUMPBIH
static void DumpBIH(unsigned char *BIH)
-{ /* For debugging */
+{
printf("biSize = %i \n",
- (BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) + (BIH[0]));
+ (int) (BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) +
+ (BIH[0]));
printf("biWidth = %i \n",
- (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]));
+ (int) (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) +
+ (BIH[4]));
printf("biHeight = %i \n",
- (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
+ (int) (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
(BIH[8]));
- printf("biPlanes = %i \n", (BIH[13] << 8) + (BIH[12]));
- printf("biBitCount = %i \n", (BIH[15] << 8) + (BIH[14]));
+ printf("biPlanes = %i \n", (int) (BIH[13] << 8) + (BIH[12]));
+ printf("biBitCount = %i \n", (int) (BIH[15] << 8) + (BIH[14]));
printf("biCompress = %i \n",
- (BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +
+ (int) (BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +
(BIH[16]));
printf("biSizeImage = %i \n",
- (BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +
+ (int) (BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +
(BIH[20]));
printf("biXPels = %i \n",
- (BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +
+ (int) (BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +
(BIH[24]));
printf("biYPels = %i \n",
- (BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +
+ (int) (BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +
(BIH[28]));
printf("biClrUsed = %i \n",
- (BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +
+ (int) (BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +
(BIH[32]));
printf("biClrImprtnt= %i \n",
- (BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +
+ (int) (BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +
(BIH[36]));
}
+#endif
+/* struct headerpair contains the decoded width/height/depth info for
+ the current bitmap */
-/*
- This does a byte-order swap. Does glib have something like
- be32_to_cpu() ??
-*/
-
-static unsigned int le32_to_cpu(guint i)
-{
- unsigned int i2;
- return i2;
-}
-
-/*
- Destroy notification function for the libart pixbuf
-*/
-
-static void free_buffer(gpointer user_data, gpointer data)
-{
- free(data);
-}
-
+struct headerpair {
+ guint width;
+ guint height;
+ guint depth;
+ guint Negative; /* Negative = 1 -> top down BMP,
+ Negative = 0 -> bottom up BMP */
+};
/* Data needed for the "state" during decompression */
struct bmp_compression_state {
gint Lines; /* # of finished lines */
gint Type; /*
+ 32 = RGB + alpha
24 = RGB
- 8 = 8 bit colormapped
+ 4 = 4 bpp colormapped
+ 8 = 8 bpp colormapped
1 = 1 bit bitonal
*/
gint Compressed;
-/* Shared library entry point */
+/* Shared library entry point --> This should be removed when
+ generic_image_load enters gdk-pixbuf-io. */
GdkPixbuf *image_load(FILE * f)
{
guchar *membuf;
size_t length;
struct bmp_progressive_state *State;
- int fd;
GdkPixbuf *pb;
while (feof(f) == 0) {
length = fread(membuf, 1, 4096, f);
if (length > 0)
- image_load_increment(State, membuf, length);
+ (void) image_load_increment(State, membuf, length);
}
g_free(membuf);
pb = State->pixbuf;
image_stop_load(State);
- return State->pixbuf;
+ return pb;
}
static void DecodeHeader(unsigned char *BFH, unsigned char *BIH,
struct bmp_progressive_state *State)
{
-/* DumpBIH(BIH);*/
+#if DUMPBIH
+ DumpBIH(BIH);
+#endif
+
State->Header.width =
- (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]);
+ (int) (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) +
+ (BIH[4]);
State->Header.height =
- (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) + (BIH[8]);
- State->Header.depth = (BIH[15] << 8) + (BIH[14]);;
+ (int) (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
+ (BIH[8]);
+ State->Header.depth = (int) (BIH[15] << 8) + (BIH[14]);;
State->Type = State->Header.depth; /* This may be less trivial someday */
State->HeaderSize =
- ((BFH[13] << 24) + (BFH[12] << 16) + (BFH[11] << 8) +
- (BFH[10]));
- if (State->HeaderSize >= 14 + 40 + 768 + 512)
- State->HeaderSize = 14 + 40 + 768 + 512 - 1;
+ (int) ((BFH[13] << 24) + (BFH[12] << 16) + (BFH[11] << 8) +
+ (BFH[10]));
+ if (State->HeaderSize >= 14 + 40 + 1024)
+ State->HeaderBuf =
+ g_realloc(State->HeaderBuf, State->HeaderSize);
if ((BIH[16] != 0) || (BIH[17] != 0) || (BIH[18] != 0)
|| (BIH[19] != 0)) {
State->Compressed = 1;
}
+ /* Negative heights indicates bottom-down pixelorder */
if (State->Header.height < 0) {
State->Header.height = -State->Header.height;
State->Header.Negative = 1;
State->Header.Negative = 0;
}
+ if (State->Type == 32)
+ State->LineWidth = State->Header.width * 4;
if (State->Type == 24)
State->LineWidth = State->Header.width * 3;
if (State->Type == 8)
State->LineWidth = State->Header.width * 1;
+ if (State->Type == 4)
+ State->LineWidth = (State->Header.width + 1) / 2;
if (State->Type == 1) {
State->LineWidth = State->Header.width / 8;
if ((State->Header.width & 7) != 0)
if (State->pixbuf == NULL) {
- State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
- (gint) State->Header.width,
- (gint) State->Header.height);
+ if (State->Type == 32)
+ State->pixbuf =
+ gdk_pixbuf_new(ART_PIX_RGB, TRUE, 8,
+ (gint) State->Header.width,
+ (gint) State->Header.height);
+ else
+ State->pixbuf =
+ gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
+ (gint) State->Header.width,
+ (gint) State->Header.height);
if (State->prepared_func != NULL)
/* Notify the client that we are ready to go */
context->user_data = user_data;
context->HeaderSize = 54;
- context->HeaderBuf = g_malloc(14 + 40 + 768 + 512);
- /* 768 for the colormap */
+ context->HeaderBuf = g_malloc(14 + 40 + 1024);
+ /* 14 for the BitmapFileHeader, 40 for the BitmapImageHeader and
+ 1024 for the colormap */
+
context->HeaderDone = 0;
context->LineWidth = 0;
if (context->LineBuf != NULL)
g_free(context->LineBuf);
context->LineBuf = NULL;
+
if (context->HeaderBuf != NULL)
g_free(context->HeaderBuf);
+ context->LineBuf = NULL;
if (context->pixbuf)
gdk_pixbuf_unref(context->pixbuf);
}
+/*
+The OneLineXX functions are called when 1 line worth of data is present.
+OneLine24 is the 24 bpp-version.
+*/
+static void OneLine32(struct bmp_progressive_state *context)
+{
+ gint X;
+ guchar *Pixels;
+
+ X = 0;
+ if (context->Header.Negative == 0)
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ (context->Header.height - context->Lines - 1);
+ else
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ context->Lines;
+ while (X < context->Header.width) {
+ Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2];
+ Pixels[X * 4 + 1] = context->LineBuf[X * 4 + 1];
+ Pixels[X * 4 + 2] = context->LineBuf[X * 4 + 0];
+ Pixels[X * 4 + 3] = context->LineBuf[X * 4 + 3];
+ X++;
+ }
+
+}
+
static void OneLine24(struct bmp_progressive_state *context)
{
gint X;
gdk_pixbuf_get_rowstride(context->pixbuf) *
context->Lines;
while (X < context->Header.width) {
- /* The joys of having a BGR byteorder */
Pixels[X * 3 + 0] =
context->HeaderBuf[4 * context->LineBuf[X] + 56];
Pixels[X * 3 + 1] =
}
}
+static void OneLine4(struct bmp_progressive_state *context)
+{
+ gint X;
+ guchar *Pixels;
+
+ X = 0;
+ if (context->Header.Negative == 0)
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ (context->Header.height - context->Lines - 1);
+ else
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ context->Lines;
+
+ while (X < context->Header.width) {
+ guchar Pix;
+
+ Pix = context->LineBuf[X / 2];
+
+ Pixels[X * 3 + 0] =
+ context->HeaderBuf[4 * (Pix >> 4) + 56];
+ Pixels[X * 3 + 1] =
+ context->HeaderBuf[4 * (Pix >> 4) + 55];
+ Pixels[X * 3 + 2] =
+ context->HeaderBuf[4 * (Pix >> 4) + 54];
+ X++;
+ if (X < context->Header.width) {
+ /* Handle the other 4 bit pixel only when there is one */
+ Pixels[X * 3 + 0] =
+ context->HeaderBuf[4 * (Pix & 15) + 56];
+ Pixels[X * 3 + 1] =
+ context->HeaderBuf[4 * (Pix & 15) + 55];
+ Pixels[X * 3 + 2] =
+ context->HeaderBuf[4 * (Pix & 15) + 54];
+ X++;
+ }
+ }
+
+}
+
static void OneLine1(struct bmp_progressive_state *context)
{
gint X;
gdk_pixbuf_get_rowstride(context->pixbuf) *
context->Lines;
while (X < context->Header.width) {
- int Bit;
+ gint Bit;
Bit = (context->LineBuf[X / 8]) >> (7 - (X & 7));
Bit = Bit & 1;
- /* The joys of having a BGR byteorder */
- Pixels[X * 3 + 0] = context->HeaderBuf[Bit + 32];
- Pixels[X * 3 + 1] = context->HeaderBuf[Bit + 2 + 32];
- Pixels[X * 3 + 2] = context->HeaderBuf[Bit + 4 + 32];
+ Pixels[X * 3 + 0] = Bit*255;
+ Pixels[X * 3 + 1] = Bit*255;
+ Pixels[X * 3 + 2] = Bit*255;
X++;
}
}
if (context->Lines >= context->Header.height)
return;
+ if (context->Type == 32)
+ OneLine32(context);
if (context->Type == 24)
OneLine24(context);
if (context->Type == 8)
OneLine8(context);
+ if (context->Type == 4)
+ OneLine4(context);
if (context->Type == 1)
OneLine1(context);
}
}
+/* DoCompressedByte handles 1 byte of incomming compressed data */
+void DoCompressedByte(struct bmp_progressive_state *context, guchar ** buf,
+ gint * size)
+{
+ gint BytesToCopy;
+ switch (context->compr.phase) {
+ case 0: /* Neutral state */
+ if (buf[0] != 0) { /* run count */
+ context->compr.phase = 1;
+ context->compr.RunCount = (*buf)[0];
+ } else { /* Escape */
+ context->compr.phase = 2;
+ }
+ (*buf)++;
+ (*size)--;
+ break;
+ case 1: /* Run count received.... */
+ while (context->compr.RunCount > 0) {
+ BytesToCopy =
+ context->LineWidth - context->LineDone;
+ if (BytesToCopy > context->compr.RunCount)
+ BytesToCopy = context->compr.RunCount;
+ if (BytesToCopy > 0) {
+ memset(context->LineBuf +
+ context->LineDone,
+ (*buf)[0], BytesToCopy);
+
+ context->compr.RunCount -= BytesToCopy;
+ context->LineDone += BytesToCopy;
+ }
+ if ((context->LineDone >= context->LineWidth)
+ && (context->LineWidth > 0)) {
+ OneLine(context);
+ }
+ }
+ context->compr.phase = 0;
+ (*buf)++;
+ (*size)--;
+ break;
+ case 2: /* Escape received */
+ if ((*buf)[0] == 0) { /* End of line */
+ context->compr.phase = 0;
+ if (context->LineDone > 0)
+ OneLine(context);
+ } else if ((*buf)[0] == 1) { /* End of image */
+ OneLine(context);
+ context->compr.phase = 6;
+ (*size) = 0;
+ break;
+ } else if ((*buf)[0] == 2) { /* Cursor displacement */
+ context->compr.phase = 4;
+ } else {
+ context->compr.phase = 3;
+ context->compr.RunCount = (*buf)[0];
+ }
+ (*buf)++;
+ (*size)--;
+
+ break;
+ case 3:
+ while ((context->compr.RunCount > 0)
+ && (size > 0)) {
+ BytesToCopy =
+ context->LineWidth - context->LineDone;
+ if (BytesToCopy > context->compr.RunCount)
+ BytesToCopy = context->compr.RunCount;
+ if (BytesToCopy > *size)
+ BytesToCopy = *size;
+
+ if (BytesToCopy > 0) {
+ memcpy(context->LineBuf +
+ context->LineDone,
+ *buf, BytesToCopy);
+
+ context->compr.RunCount -= BytesToCopy;
+ (*buf) += BytesToCopy;
+ (*size) -= BytesToCopy;
+ context->LineDone += BytesToCopy;
+ }
+ if ((context->LineDone >= context->LineWidth)
+ && (context->LineWidth > 0))
+ OneLine(context);
+ }
+ if (context->compr.RunCount <= 0)
+ context->compr.phase = 0;
+
+ break;
+ case 4:
+ context->compr.phase = 5;
+ context->compr.XDelta = (*buf)[0];
+ (*buf)++;
+ (*size)--;
+ break;
+ case 5:
+ context->compr.phase = 0;
+ context->compr.YDelta = (*buf)[0];
+ g_assert(0); /* No implementatio of this yet */
+ /* If this happens, please email me (arjan@fenrus.demon.nl)
+ the image concerned. */
+ (*buf)++;
+ (*size)--;
+ break;
+ case 6:
+ (*size) = 0;
+ }
+}
+
/*
* context - from image_begin_load
* buf - new image data
if (BytesToCopy > size)
BytesToCopy = size;
- memcpy(context->HeaderBuf + context->HeaderDone,
+ memmove(context->HeaderBuf + context->HeaderDone,
buf, BytesToCopy);
size -= BytesToCopy;
context->HeaderDone += BytesToCopy;
} else if (context->Compressed) {
- /* Compression is done 1 at a time for now */
- switch (context->compr.phase) {
- case 0:
- if (buf[0] != 0) { /* run count */
- context->compr.phase = 1;
- context->compr.RunCount = buf[0];
- } else { /* Escape */
- context->compr.phase = 2;
- }
- buf++;
- size--;
- break;
- case 1: /* Run count received.... */
- while (context->compr.RunCount > 0) {
- BytesToCopy =
- context->LineWidth -
- context->LineDone;
- if (BytesToCopy >
- context->compr.
- RunCount) BytesToCopy =
- context->compr.
- RunCount;
- if (BytesToCopy > 0) {
- memset(context->LineBuf +
- context->LineDone,
- buf[0],
- BytesToCopy);
-
- context->compr.RunCount -=
- BytesToCopy;
- context->LineDone +=
- BytesToCopy;
- }
- if (
- (context->LineDone >=
- context->LineWidth)
- && (context->LineWidth > 0)) {
- OneLine(context);
- }
- }
- context->compr.phase = 0;
- buf++;
- size--;
- break;
- case 2: /* Escape received */
- if (buf[0] == 0) { /* End of line */
- context->compr.phase = 0;
- if (context->LineDone > 0)
- OneLine(context);
- } else if (buf[0] == 1) { /* End of image */
- OneLine(context);
- context->compr.phase = 6;
- size = 0;
- break;
- } else if (buf[0] == 2) { /* Cursor displacement */
- context->compr.phase = 4;
- } else {
- context->compr.phase = 3;
- context->compr.RunCount = buf[0];
- }
- buf++;
- size--;
-
- break;
- case 3:
- while ((context->compr.RunCount > 0)
- && (size > 0)) {
- BytesToCopy =
- context->LineWidth -
- context->LineDone;
- if (BytesToCopy >
- context->compr.
- RunCount) BytesToCopy =
- context->compr.
- RunCount;
- if (BytesToCopy > size)
- BytesToCopy = size;
-
- if (BytesToCopy > 0) {
- memcpy(context->LineBuf +
- context->LineDone,
- buf, BytesToCopy);
-
- context->compr.RunCount -=
- BytesToCopy;
- buf += BytesToCopy;
- size -= BytesToCopy;
- context->LineDone +=
- BytesToCopy;
- }
- if (
- (context->LineDone >=
- context->LineWidth)
- && (context->LineWidth > 0))
- OneLine(context);
- }
- if (context->compr.RunCount <= 0)
- context->compr.phase = 0;
-
- break;
- case 4:
- context->compr.phase = 5;
- context->compr.XDelta = buf[0];
- buf++;
- size--;
- break;
- case 5:
- context->compr.phase = 0;
- context->compr.YDelta = buf[0];
- g_assert(0); /* No implementatio of this yet */
- buf++;
- size--;
- break;
- case 6:
- size = 0;
- }
+ /* Compression is done 1 byte at a time for now */
+ DoCompressedByte(context, &buf, &size);
} else {
- /* Pixeldata only */
+ /* Uncompressed pixeldata */
BytesToCopy =
context->LineWidth - context->LineDone;
if (BytesToCopy > size)
BytesToCopy = size;
if (BytesToCopy > 0) {
- memcpy(context->LineBuf +
+ memmove(context->LineBuf +
context->LineDone, buf,
BytesToCopy);
-/* GdkPixbuf library - Windows Bitmap image loader
+/* GdkPixbuf library - Windows Icon/Cursor image loader
*
* Copyright (C) 1999 The Free Software Foundation
*
* Boston, MA 02111-1307, USA.
*/
+#undef DUMPBIH
/*
Icons are just like BMP's, except for the header.
\f
-struct headerpair {
- guint width;
- guint height;
- guint depth;
- guint Negative; /* Negative = 1 -> top down BMP,
- Negative = 0 -> bottom up BMP */
-};
/*
These structures are actually dummies. These are according to
-the "Windows API reference guide volume II" as written by Borland,
-but GCC fiddles with the alignment of the internal members.
+the "Windows API reference guide volume II" as written by
+Borland International, but GCC fiddles with the alignment of
+the internal members.
*/
guint biClrImportant;
};
+#ifdef DUMPBIH
+/*
+
+DumpBIH printf's the values in a BitmapInfoHeader to the screen, for
+debugging purposes.
+
+*/
static void DumpBIH(unsigned char *BIH)
-{ /* For debugging */
+{
printf("biSize = %i \n",
- (BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) + (BIH[0]));
+ (int)(BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) + (BIH[0]));
printf("biWidth = %i \n",
- (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]));
+ (int)(BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]));
printf("biHeight = %i \n",
- (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
+ (int)(BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
(BIH[8]));
- printf("biPlanes = %i \n", (BIH[13] << 8) + (BIH[12]));
- printf("biBitCount = %i \n", (BIH[15] << 8) + (BIH[14]));
+ printf("biPlanes = %i \n", (int)(BIH[13] << 8) + (BIH[12]));
+ printf("biBitCount = %i \n", (int)(BIH[15] << 8) + (BIH[14]));
printf("biCompress = %i \n",
- (BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +
+ (int)(BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +
(BIH[16]));
printf("biSizeImage = %i \n",
- (BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +
+ (int)(BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +
(BIH[20]));
printf("biXPels = %i \n",
- (BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +
+ (int)(BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +
(BIH[24]));
printf("biYPels = %i \n",
- (BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +
+ (int)(BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +
(BIH[28]));
printf("biClrUsed = %i \n",
- (BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +
+ (int)(BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +
(BIH[32]));
printf("biClrImprtnt= %i \n",
- (BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +
+ (int)(BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +
(BIH[36]));
}
-
-/*
- This does a byte-order swap. Does glib have something like
- be32_to_cpu() ??
-*/
-
-static unsigned int le32_to_cpu(guint i)
-{
- unsigned int i2;
- return i2;
-}
-
-/*
- Destroy notification function for the libart pixbuf
-*/
-
-static void free_buffer(gpointer user_data, gpointer data)
-{
- free(data);
-}
-
+#endif
/* Progressive loading */
+struct headerpair {
+ guint width;
+ guint height;
+ guint depth;
+ guint Negative; /* Negative = 1 -> top down BMP,
+ Negative = 0 -> bottom up BMP */
+};
struct ico_progressive_state {
ModulePreparedNotifyFunc prepared_func;
-/* Shared library entry point */
+/* Shared library entry point --> Can go when generic_image_load
+ enters gdk-pixbuf-io */
GdkPixbuf *image_load(FILE * f)
{
guchar *membuf;
size_t length;
struct ico_progressive_state *State;
- int fd;
GdkPixbuf *pb;
while (feof(f) == 0) {
length = fread(membuf, 1, 4096, f);
if (length > 0)
- image_load_increment(State, membuf, length);
+ (void)image_load_increment(State, membuf, length);
}
g_free(membuf);
pb = State->pixbuf;
image_stop_load(State);
- return State->pixbuf;
+ return pb;
}
static void DecodeHeader(guchar *Data, gint Bytes,
IconCount = (Data[5] << 8) + (Data[4]);
-/* printf("There are %i icons in this file \n",IconCount);*/
State->HeaderSize = 6 + IconCount*16;
if (State->HeaderSize>State->BytesInHeaderBuf) {
ThisHeight = Ptr[1];
ThisColors = (Ptr[2]);
if (ThisColors==0)
- ThisColors=256; /* Yes, this is in the spec */
+ ThisColors=256; /* Yes, this is in the spec, ugh */
-/* printf("Option: %ix%ix%i ",ThisWidth,ThisHeight,ThisColors);*/
-
ThisScore = ThisColors*1024+ThisWidth*ThisHeight;
if (ThisScore>State->ImageScore) {
State->ImageScore = ThisScore;
State->DIBoffset = (Ptr[15]<<24)+(Ptr[14]<<16)+
(Ptr[13]<<8) + (Ptr[12]);
-/* printf("*");*/
}
-/* printf("\n");*/
Ptr += 16;
}
BIH = Data+State->DIBoffset;
-/* DumpBIH(BIH);*/
+#ifdef DUMPBIH
+ DumpBIH(BIH);
+#endif
/* Add the palette to the headersize */
State->Header.width =
- (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]);
+ (int)(BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]);
State->Header.height =
- (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) + (BIH[8])/2;
+ (int)(BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) + (BIH[8])/2;
/* /2 because the BIH height includes the transparency mask */
State->Header.depth = (BIH[15] << 8) + (BIH[14]);;
- State->Type = State->Header.depth; /* This may be less trivial someday */
+ State->Type = State->Header.depth;
if (State->Lines>=State->Header.height)
- State->Type = 1;
+ State->Type = 1; /* The transparency mask is 1 bpp */
+
- I =(BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) + (BIH[32]);
+
+ /* Determine the palette size. If the header indicates 0, it
+ is actually the maximum for the bpp. You have to love the
+ guys who made the spec. */
+ I =(int)(BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) + (BIH[32]);
if ((I==0)&&(State->Type==1))
I = 2*4;
if ((I==0)&&(State->Type==4))
g_assert(0); /* Compressed icons aren't allowed */
}
+ /* Negative heights mean top-down pixel-order */
if (State->Header.height < 0) {
State->Header.height = -State->Header.height;
State->Header.Negative = 1;
}
if (State->Header.width < 0) {
State->Header.width = -State->Header.width;
- State->Header.Negative = 0;
}
if (State->Type == 24)
if (State->Type == 8)
State->LineWidth = State->Header.width * 1;
if (State->Type == 4) {
- State->LineWidth = State->Header.width/2;
- if ((State->Header.width & 1) != 0)
- State->LineWidth++;
+ State->LineWidth = (State->Header.width+1)/2;
}
if (State->Type == 1) {
State->LineWidth = State->Header.width / 8;
/* Pad to a 32 bit boundary */
if (((State->LineWidth % 4) > 0))
- State->LineWidth = (State->LineWidth / 3) * 3 + 3;
+ State->LineWidth = (State->LineWidth / 4) * 4 + 4;
if (State->LineBuf == NULL)
Bit = (context->LineBuf[X / 8]) >> (7 - (X & 7));
Bit = Bit & 1;
/* The joys of having a BGR byteorder */
- Pixels[X * 4 + 0] = context->HeaderBuf[Bit + 32];
- Pixels[X * 4 + 1] = context->HeaderBuf[Bit + 2 + 32];
- Pixels[X * 4 + 2] = context->HeaderBuf[Bit + 4 + 32];
+ Pixels[X * 4 + 0] = Bit*255;
+ Pixels[X * 4 + 1] = Bit*255;
+ Pixels[X * 4 + 2] = Bit*255;
X++;
}
}
gint BytesToCopy;
while (size > 0) {
-/* printf("Y=%i C=%i H=%i\n",context->Lines,context->Type,context->Header.height);*/
g_assert(context->LineDone >= 0);
if (context->HeaderDone < context->HeaderSize) { /* We still
have headerbytes to do */
if (BytesToCopy > size)
BytesToCopy = size;
- memcpy(context->HeaderBuf + context->HeaderDone,
+ memmove(context->HeaderBuf + context->HeaderDone,
buf, BytesToCopy);
size -= BytesToCopy;
BytesToCopy = size;
if (BytesToCopy > 0) {
- memcpy(context->LineBuf +
+ memmove(context->LineBuf +
context->LineDone, buf,
BytesToCopy);
projects / gtk4.git / commitdiff